home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 May: Tool Chest / Developer CD Series May 1996 (Tool Chest) (Apple Computer) (1996).iso / Tool Chest / Development Tools & Languages / Macintosh Common Lisp Related / interfaces / PInterface Translator / PInterfaces / MoviesFormat.p < prev    next >
Encoding:
Text File  |  1993-09-16  |  12.1 KB  |  480 lines  |  [TEXT/MPS ]
  1.  
  2. {************************************************************
  3. Created: Monday, August 17, 1992 at 5:13 PM
  4.  MoviesFormat.p
  5.  Pascal Interface to the Macintosh Libraries
  6.  
  7.  
  8.  Copyright Apple Computer, Inc. 1991, 1992
  9.  All rights reserved
  10.  
  11.  03/10/93 bill pulled trackDirectoryArray def out of in-line in MovieDirectory
  12.                definition so that the translator could deal.
  13.  
  14. ************************************************************}
  15.  
  16. {$IFC UNDEFINED UsingIncludes}
  17. {$SETC UsingIncludes := 0}
  18. {$ENDC}
  19.  
  20. {$IFC NOT UsingIncludes}
  21.  UNIT MoviesFormat;
  22.  INTERFACE
  23. {$ENDC}
  24.  
  25. {$IFC UNDEFINED UsingMoviesFormat}
  26. {$SETC UsingMoviesFormat := 1}
  27.  
  28. {$I+}
  29. {$SETC MoviesFormatIncludes := UsingIncludes}
  30. {$SETC UsingIncludes := 1}
  31.  
  32. {$IFC UNDEFINED UsingMovies}
  33. {$I $$Shell(PInterfaces)Movies.p}
  34. {$ENDC}
  35. {$IFC UNDEFINED UsingImageCompression}
  36. {$I $$Shell(PInterfaces)ImageCompression.p}
  37. {$ENDC}
  38. {$SETC UsingIncludes := MoviesFormatIncludes}
  39.  
  40. CONST
  41. kMovieVersion = 0;                { version number of the format here described }
  42.  
  43.  
  44. {****************************************
  45. *
  46. *   General Types -
  47. *        These types are used in more than one of the
  48. *        directory types.
  49. *
  50. ****************************************}
  51.  
  52. { MoviesUserData is the type used for user data in movie and track directories }
  53.  
  54. TYPE
  55.  
  56. MoviesUserData = RECORD
  57.     size    :    LONGINT;         { size of this user data }
  58.     udType    :    LONGINT;         { type of user data  }
  59.     data    :    PACKED ARRAY[0..0] OF Byte;         { the user data } 
  60. END;
  61.  
  62. UserDataAtom = RECORD
  63.     size        :    LONGINT;    
  64.     atomType    :    LONGINT; 
  65.     userData    :    ARRAY[0..0] OF MoviesUserData;
  66. END;
  67.  
  68.  
  69. { MoviesDataDescription tells us where the data for the movie or track lives.
  70.    The data can follow the directory, be in the datafork of the same file as the directory resource,
  71.    be in the resource fork of the same file as the directory resource, be in another file in the 
  72.    data fork or resource fork, or require a specific bottleneck to fetch the data. }
  73.  
  74.  
  75. {***************************************
  76. *
  77. *   MediaDirectory information -
  78. *        The MediaDirectory is tightly coupled to the data.
  79. *
  80. ***************************************}
  81.  
  82. { The SampleDescriptionTable holds the SampleDescriptions needed to decompress chunks given the
  83.    SampleDescriptionID. There is a table per Media. }
  84.  
  85. {
  86. SampleDescription = RECORD
  87.     size        :    LONGINT;
  88.     dataFormat    :    LONGINT;
  89.     resvd1        :    LONGINT;
  90.     resvdA        :    INTEGER;
  91.     dataRefId    :    INTEGER;
  92. END;
  93. SampleDescriptionHandle = ^^SampleDescription;
  94. }
  95.  
  96. SampleDescriptionAtom = RECORD
  97.     size            :    LONGINT;
  98.     atomType        :    LONGINT;            { = 'stsd' }
  99.     flags            :    LONGINT;            { 1 byte of version / 3 bytes of flags }
  100.     numEntries        :    LONGINT;
  101.     sampleDescTable    :    ARRAY[0..0] OF SampleDescription;
  102. END;
  103.  
  104. { TimeToSampleNum maps physical sample time to physical sample number. }
  105.  
  106. TimeToSampleNum = RECORD
  107.     sampleCount     :    LONGINT;
  108.     sampleDuration    :    TimeValue;
  109. END;
  110.  
  111. TimeToSampleNumAtom = RECORD
  112.     size        :    LONGINT;
  113.     atomType    :    LONGINT;            { = 'stts' }
  114.     flags        :    LONGINT;            { 1 byte of version / 3 bytes of flags }
  115.     numEntries    :    LONGINT;
  116.     timeToSampleNumTable : ARRAY[0..0] OF TimeToSampleNum;
  117. END;
  118.  
  119. { SyncSamples is a list of the physical samples which are self contained. }
  120.  
  121. SyncSampleAtom = RECORD
  122.     size            :    LONGINT;
  123.     atomType        :    LONGINT;        { = 'stss' }
  124.     flags            :    LONGINT;        { 1 byte of version / 3 bytes of flags }
  125.     numEntries        :    LONGINT;
  126.     syncSampleTable    :    ARRAY[0..0] OF LONGINT;
  127. END;
  128.  
  129. SampleToChunk = RECORD
  130.     firstChunk            :    LONGINT;
  131.     samplesPerChunk        :    LONGINT;
  132.     sampleDescriptionID    :    LONGINT;
  133. END;
  134.  
  135. SampleToChunkAtom = RECORD
  136.     size                :    LONGINT;        
  137.     atomType            :    LONGINT;    { = 'stsc' }
  138.     flags                :    LONGINT;    { 1 byte of version / 3 bytes of flags }
  139.     numEntries            :    LONGINT;        
  140.     sampleToChunkTable     :    ARRAY[0..0] OF SampleToChunk;
  141. END;
  142.  
  143. ChunkOffsetAtom = RECORD
  144.     size                :    LONGINT;    
  145.     atomType            :    LONGINT;                { = 'stco' }
  146.     flags                :    LONGINT;                { 1 byte of version / 3 bytes of flags }
  147.     numEntries            :    LONGINT;    
  148.     chunkOffsetTable    :    ARRAY[0..0] OF LONGINT;
  149. END;
  150.  
  151. SampleSizeAtom = RECORD
  152.     size            :    LONGINT;        
  153.     atomType        :    LONGINT;        { = 'stsz' }
  154.     flags            :    LONGINT;        { 1 byte of version / 3 bytes of flags }
  155.     sampleSize        :    LONGINT;        
  156.     numEntries        :    LONGINT;        
  157.     sampleSizeTable :    ARRAY[0..0] OF LONGINT;
  158. END;
  159.  
  160. ShadowSync = RECORD
  161.     fdSampleNum        :    LONGINT;
  162.     syncSampleNum     :    LONGINT;
  163. END;
  164.  
  165. ShadowSyncAtom = RECORD
  166.     size            :    LONGINT;
  167.     atomType        :    LONGINT;
  168.     flags            :    LONGINT;
  169.     numEntries        :    LONGINT;
  170.     shadowSyncTable    :    ARRAY[0..0] OF ShadowSync;
  171. END;
  172.  
  173. SampleTableAtom = RECORD
  174.     size                :    LONGINT;    
  175.     atomType            :    LONGINT;        { = 'stbl' }
  176.     sampleDescription    :    SampleDescriptionAtom;
  177.     timeToSampleNum        :    TimeToSampleNumAtom;
  178.     sampleToChunk        :    SampleToChunkAtom;
  179.     syncSample            :    SyncSampleAtom;
  180.     sampleSize            :    SampleSizeAtom;
  181.     chunkOffset            :    ChunkOffsetAtom;
  182.     shadowSync            :    ShadowSyncAtom;
  183. END;
  184.  
  185. PublicHandlerInfo = RECORD
  186.     flags                    :    LONGINT;    { 1 byte of version / 3 bytes of flags }
  187.     componentType            :    LONGINT;            
  188.     componentSubType        :    LONGINT;                
  189.     componentManufacturer    :    LONGINT;                
  190.     componentFlags            :    LONGINT;                
  191.     componentFlagsMask        :    LONGINT;                
  192.     componentName            :    PACKED ARRAY[0..0] OF Byte;
  193. END;
  194.     
  195. HandlerAtom = RECORD
  196.     size        :    LONGINT;        
  197.     atomType    :    LONGINT;        { = 'hdlr' }
  198.     hInfo        :    PublicHandlerInfo;    
  199. END;
  200.     
  201. DataRefAtom = LONGINT;
  202.  
  203. DataInfoAtom = RECORD
  204.     size        :    LONGINT;        
  205.     atomType    :    LONGINT;            { = 'dinf' }
  206.     dataRef        :    DataRefAtom;
  207. END;
  208.  
  209. RgnAtom = RECORD
  210.     size        :    LONGINT;        
  211.     atomType    :    LONGINT;        
  212.     rgnSize        :    INTEGER;        { this is the contents of a region }
  213.     rgnBBox        :    Rect;
  214.     data        :    ARRAY[0..0] OF Byte;
  215. END;
  216.  
  217. MatteCompressedAtom = RECORD
  218.     size        :    LONGINT;                
  219.     atomType    :    LONGINT;                
  220.     flags        :    LONGINT;            { 1 byte of version / 3 bytes of flags }
  221.     matteImageDescription     :     ImageDescription;
  222.     matteData                 :    PACKED ARRAY[0..0] OF Byte;
  223. END;
  224.  
  225. MatteAtom = RECORD
  226.     size                :    LONGINT;                
  227.     atomType            :    LONGINT;            
  228.     aCompressedMatte    :    MatteCompressedAtom;
  229. END;
  230.  
  231. ClippingAtom = RECORD
  232.     size        :    LONGINT;    
  233.     atomType    :    LONGINT;        
  234.     aRgnClip    :    RgnAtom;
  235. END;
  236.     
  237. {***********************
  238. * Media Info Example Structures 
  239. ***********************}    
  240.  
  241. VideoMediaInfoHeader = RECORD
  242.     flags            :    LONGINT;        { 1 byte of version / 3 bytes of flags }
  243.     graphicsMode    :    INTEGER;        { for QD - transfer mode }
  244.     opColorRed        :    INTEGER;        { opcolor for transfer mode }
  245.     opColorGreen    :    INTEGER;
  246.     opColorBlue        :    INTEGER;
  247. END;
  248.  
  249. VideoMediaInfoHeaderAtom = RECORD
  250.     size        :    LONGINT;                { size of Media info }
  251.     atomType    :    LONGINT;                { = 'vmhd' }
  252.     vmiHeader    :    VideoMediaInfoHeader;
  253. END;
  254.  
  255. VideoMediaInfo = RECORD
  256.     size        :    LONGINT;            { size of Media info }
  257.     atomType    :    LONGINT;            { = 'minf' }
  258.     header        :    VideoMediaInfoHeaderAtom;
  259.     dataHandler    :    HandlerAtom;
  260.     dataInfo    :    DataInfoAtom;
  261.     sampleTable    :    SampleTableAtom;
  262. END;
  263.  
  264. SoundMediaInfoHeader = RECORD
  265.     flags    :    LONGINT;            { 1 byte of version / 3 bytes of flags }
  266.     balance    :    INTEGER;                
  267.     rsrvd    :    INTEGER;
  268. END;
  269.  
  270. SoundMediaInfoHeaderAtom = RECORD
  271.     size        :    LONGINT;            { size of Media info }
  272.     atomType    :    LONGINT;            { = 'vmhd' }
  273.     smiHeader    :    SoundMediaInfoHeader;    
  274. END;
  275.  
  276. SoundMediaInfo = RECORD
  277.     size            :    LONGINT;        { size of Media info }
  278.     atomType        :    LONGINT;        { = 'minf' }
  279.     header            :    SoundMediaInfoHeaderAtom;
  280.     dataHandler        :    HandlerAtom;
  281.     dataReference    :    DataRefAtom;
  282.     sampleTable        :    SampleTableAtom;
  283. END;
  284.  
  285. MediaInfo = RECORD
  286.     size        :    LONGINT;    
  287.     atomType    :    LONGINT;    
  288.     { whatever data the media handler needs goes here }
  289. END;
  290.  
  291.  
  292. {**********************
  293. * Media Directory Structures 
  294. **********************}    
  295.  
  296. MediaHeader = RECORD
  297.     flags                :    LONGINT;    { 1 byte of version / 3 bytes of flags }
  298.     creationTime        :    LONGINT;    { seconds since Jan 1904 when directory was created }
  299.     modificationTime    :    LONGINT;    { seconds since Jan 1904 when directory was appended }
  300.     timeScale            :    TimeValue;    { start time for Media (Media time) }
  301.     duration            :    TimeValue;    { length of Media (Media time) }
  302.     language            :    INTEGER;
  303.     quality                :    INTEGER;
  304. END;
  305.  
  306. MediaHeaderAtom = RECORD
  307.     size        :    LONGINT;         
  308.     atomType    :    LONGINT;                
  309.     header        :    MediaHeader;
  310. END;
  311.  
  312. MediaDirectory = RECORD
  313.     size            :    LONGINT;
  314.     atomType        :    LONGINT;            { = 'mdia' }
  315.     mediaHeader     :     MediaHeaderAtom;    { standard Media information }
  316.     mHandler         :     HandlerAtom;
  317.     mediaInfo        :    MediaInfo;
  318. END;
  319.  
  320. {**********************
  321. * Track Structures 
  322. **********************}    
  323.  
  324. CONST    
  325.     TrackEnable     = 1;
  326.     TrackInMovie     = 2;
  327.     TrackInPreview     = 4;
  328.     TrackInPoster     = 8;
  329.     
  330. TYPE    
  331. TrackHeader = RECORD
  332.     flags            :    LONGINT;    { 1 byte of version / 3 bytes of flags }
  333.     creationTime    :    LONGINT;    { seconds since Jan 1904 when directory was created }
  334.     modificationTime :    LONGINT;    { seconds since Jan 1904 when directory was appended }
  335.     trackID            :    LONGINT;
  336.     reserved1        :    LONGINT;
  337.     duration        :    TimeValue;    { length of track (track time) }
  338.     reserved2        :    LONGINT;
  339.     reserved3        :    LONGINT;
  340.     layer            :    INTEGER;
  341.     alternateGroup    :    INTEGER;
  342.     volume            :    INTEGER;
  343.     reserved4        :    INTEGER;
  344.     matrix            :    MatrixRecord;
  345.     trackWidth        :    Fixed;
  346.     trackHeight        :    Fixed;
  347. END;
  348.  
  349. TrackHeaderAtom = RECORD 
  350.     size        :    LONGINT;    { size of track header }
  351.     atomType    :    LONGINT;    { = 'tkhd' }
  352.     header        :    TrackHeader;
  353. END;
  354.  
  355. EditListType = RECORD 
  356.     trackDuration     :     TimeValue;
  357.     mediaTime        :    TimeValue;
  358.     mediaRate        :    Fixed;
  359. END;
  360.  
  361. EditListAtom    =    RECORD
  362.     size            :    LONGINT;
  363.     atomType        :    LONGINT;     { = elst }
  364.     flags            :    LONGINT;    { 1 byte of version / 3 bytes of flags }
  365.     numEntries        :    LONGINT;
  366.     editListTable     :     ARRAY[0..0] OF EditListType;
  367. END;
  368.  
  369. EditsAtom = RECORD
  370.     size        :    LONGINT;
  371.     atomType    :    LONGINT;    { = edts }
  372.     editList    :    EditListAtom;
  373. END;
  374.  
  375. TrackDirectory = RECORD
  376.     size            :    LONGINT;
  377.     atomType        :    LONGINT;            { = 'trak' }
  378.     trackHeader        :    TrackHeaderAtom;    { standard track information }
  379.     trackClip        :    ClippingAtom;
  380.     edits            :    EditsAtom;
  381.     media            :    MediaDirectory;
  382.      userData        :    UserDataAtom;        { space for extending with new data types }
  383. END;
  384.  
  385. MovieHeader = RECORD
  386.     flags                :    LONGINT;        { 1 byte of version / 3 bytes of flags }
  387.     creationTime        :    LONGINT;        { seconds since Jan 1904 when directory was created }
  388.     modificationTime     :    LONGINT;        { seconds since Jan 1904 when directory was appended }
  389.  
  390.     { Time specifications }
  391.     timeScale        :    TimeValue;
  392.     duration        :    TimeValue;
  393.     
  394.     preferredRate    :    Fixed;            { rate at which to play this movie }
  395.     preferredVolume    :    INTEGER;        { volume to play movie at }
  396.     reserved1        :    INTEGER;            
  397.  
  398.     { Graphics specifications }
  399.     reserved2            :    LONGINT;                    
  400.     reserved3            :    LONGINT;                    
  401.  
  402.     matrix                :    MatrixRecord;
  403.     
  404.     previewTime            :    TimeValue;        { time in track the proxy begins (track time) }
  405.     previewDuration        :    TimeValue;        { how long the proxy lasts (track time) }
  406.     posterTime             :    TimeValue;        { time in track the proxy begins (track time) }
  407.     selectionTime        :    TimeValue;        { time in track the proxy begins (track time) }
  408.     selectionDuration    :    TimeValue;        { time in track the proxy begins (track time) }
  409.     currentTime            :    TimeValue;        { time in track the proxy begins (track time) }
  410.     nextTrackID            :    LONGINT;        { next value to use for a TrackID }
  411. END;
  412.  
  413. MovieHeaderAtom = RECORD
  414.     size        :    LONGINT;
  415.     atomType    :    LONGINT;                        { = 'mvhd' }
  416.     header        :    MovieHeader;
  417. END;
  418.  
  419. trackDirectoryArray = RECORD
  420.     trackDirectory    :    ARRAY[0..0] OF TrackDirectory;
  421. END;
  422.   
  423. MovieDirectory = RECORD
  424.     size        :    LONGINT;
  425.     atomType    :    LONGINT;                        { = 'moov' }
  426.     header        :    MovieHeaderAtom;
  427.     movieClip    :    ClippingAtom;                
  428.     { Track Directories }
  429.     track        :    trackDirectoryArray;
  430.      { User data for Movie }
  431.      userData    :    UserDataAtom;                    { space for user extensions }
  432. END;
  433.  
  434. CONST
  435. { Movie formats and tags }
  436.     { some system defined format IDs }
  437.     MOVIE_TYPE    =    'moov';
  438.     TRACK_TYPE    =    'trak';
  439.     MEDIA_TYPE    =    'mdia';
  440.     VIDEO_TYPE    =    'vide';
  441.     SOUND_TYPE    =    'soun';
  442.  
  443. { atom id's }
  444.     MovieAID                =    'moov';
  445.     MovieHeaderAID            =    'mvhd';
  446.     ClipAID                    =    'clip';
  447.     RgnClipAID                =    'crgn';
  448.     MatteAID                =    'matt';
  449.     MatteCompAID            =    'kmat';
  450.     TrackAID                =    'trak';
  451.     UserDataAID                =    'udta';
  452.     TrackHeaderAID            =    'tkhd';
  453.     EditsAID                =    'edts';
  454.     EditListAID                =    'elst';
  455.     MediaAID                =    'mdia';
  456.     MediaHeaderAID            =    'mdhd';
  457.     MediaInfoAID            =    'minf';
  458.     VideoMediaInfoHeaderAID    =    'vmhd';
  459.     SoundMediaInfoHeaderAID    =    'smhd';
  460.     GenericMediaInfoHeaderAID = 'gmhd';
  461.     GenericMediaInfoAID        =    'gmin';
  462.     DataInfoAID                =    'dinf';
  463.     DataRefAID                =    'dref';
  464.     SampleTableAID            =    'stbl';
  465.     STSampleDescAID            =    'stsd';
  466.     STTimeToSampAID            =    'stts';
  467.     STSyncSampleAID            =    'stss';
  468.     STSampleToChunkAID        =    'stsc';
  469.     STShadowSyncAID            =    'stsh';
  470.     HandlerAID                =    'hdlr';
  471.     STSampleSizeAID            =    'stsz';
  472.     STChunkOffsetAID        =    'stco';
  473.     DataRefContainerAID     =    'drfc';
  474.     
  475. {$ENDC} { UsingMoviesFormat }
  476.  
  477. {$IFC NOT UsingIncludes}
  478.  END.
  479. {$ENDC}
  480.